/**
 * Created by leezhihua on 2018/7/20
 * @flow
 * */

'use strict';

import React, {Component} from 'react';

let Data = {
    /**
     * 把json字符串转化为对象
     * @param  {string}  data            需要转化的字符串
     */
    transformToJSONObject(data) {
        if (typeof data === 'string' && (data.indexOf('{') > -1 || data.indexOf('[') > -1)) {
            try {
                data = JSON.parse(data);
            } catch (ex) {
                console.log('数据格式错误');
            }
        }
        return data;
    },

    /**
     * 把object对象转成json字符串
     * @param  {object}  data            需要转化的对象
     * @return string
     */
    transformToJSONString(data) {
        try {
            if (typeof data === "string"){
                return data
            }
            data = JSON.stringify(data);
        } catch (ex) {
            console.log('数据格式错误');
        }
        return data;
    },

    /**
     * url进行编码
     * @param  {String} str 编码字符串
     * @return {String} 编码后的值
     */
    encodeURL(str) {
        return encodeURIComponent(str);
    },

    /**
     * url进行解码
     * @param  {String} str 解码字符串
     * @return {String} 解码后的值
     */
    decodeURL(str) {
        return decodeURIComponent(str);
    },

    /**
     * JSON转成字符串
     * @param  {Object} json json对象
     * @return {String}     转化后字符串
     */
    stringify(json) {
        if (json === null || json === undefined) {
            return json;
        }
        if (JSON && JSON.stringify) {
            return JSON.stringify(json);
        } else {
            let str = '';
            if (json.length !== undefined) {
                //数组
                for (let i in json) {
                    let item = json[i],
                        sType = typeof item;

                    if (item === undefined) {
                        str += null + ',';
                    } else if (sType === 'object') {
                        str += this.stringify(item) + ',';
                    } else if (sType === 'string') {
                        str += '"' + item + '"' + ',';
                    } else if (sType === 'function') {
                        str += null + ',';
                    } else {
                        str += item + ',';
                    }
                }
                if (str) {
                    str = str.substr(0, str.length - 1);
                }
                str = '[' + str + ']';
            } else {
                //对象
                for (let key in json) {
                    let item = json[key],
                        sType = typeof item,
                        sFormat = '"{key}":{val},';

                    if (item === undefined || sType === 'function') {
                        continue;
                    }
                    if (sType === 'object') {
                        item = this.stringify(item);
                    } else if (sType === 'string') {
                        item = '"' + item + '"';
                        4;
                    }
                    str += this.substitute(sFormat, {key: key, val: item});
                }
                if (str) {
                    str = str.substr(0, str.length - 1);
                }
                str = '{' + str + '}';
            }
            return str;
        }
    },

    /**
     * 占位符替换工厂。
     *
     * @method
     * @param {String} sContent 含占位符的字符串。
     *    当要被替换的内容中含未知替换数据，则会保留当前点位符。
     * @param {Object} oData 要替换的点位符数据，依据对象的键名与点位符一一对应，功能类似 KISSY.substitute。
     * @return {String} 返回替换后的字符串。
     */
    substitute(sContent, oData) {
        if (!oData) {
            return sContent;
        }

        for (let p in oData) {
            sContent = sContent.replace(new RegExp('\\{' + p + '\\}', 'g'), oData[p]);
        }

        return sContent;
    },

    /**
     * 将字数符反参数解决成对象。
     * 与 $.param 相对。
     *
     * @method
     * @param {String} sParams
     * @return {Object}
     */
    unparam(sParams) {
        let asParams = (sParams || '').split('&'),
            oParams = {},
            asSplitedParam = [];
        for (let i = asParams.length - 1; i >= 0; i--) {
            asSplitedParam = asParams[i].split('=');
            oParams[asSplitedParam[0]] = asSplitedParam[1] || '';
        }

        return oParams;
    },

    /**
     * 字符串转成json对象
     * @param  {String} str     要转化的字符串
     * @return {Object}
     */
    parseJson(str) {
        if (!str) {
            return {};
        }
        if (typeof str === 'object') {
            return str;
        }
        if (window.JSON && JSON.parse) {
            return JSON.parse(str);
        } else {
            try {
                return eval('a=' + str);
            } catch (ex) {
                console.log('格式转化出错');
                return {};
            }
        }
    },

    /**
     * 从 URL 中读取某个参数值。
     *
     * @method getParam
     * @param {String} sName
     * @param {String|undefined} sHref ({location.href})
     * @return {String}
     */
    getParam(sName, sHref) {
        return this.decodeURL(this.unparam((sHref || location.href).split('?')[1] || '')[sName] || '').replace(/#*?/g, '');
    },

    /**
     * 检查数据是否为空
     * @param obj
     * @returns {boolean}
     */
    isEmpty(v) {
        switch (typeof v) {
            case 'undefined':
                return true;
            case 'string':
                // .replace(/(^s*)|(s*$)/g, '').length == 0
                if (v.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, '').length == 0) return true;
                break;
            case 'boolean':
                if (!v) return true;
                break;
            // case 'number':
            //   if (0 === v || isNaN(v)) return true;
            //   break;
            case 'object':
                if (null === v || v.length === 0) return true;
                for (var i in v) {
                    return false;
                }
                return true;
        }
        return false;
    },
    /**
     * 生成唯一识别码
     * @return {String} 识别码
     */
    getGuid() {
        let guid = '';
        for (let i = 1; i <= 32; i++) {
            let n = Math.floor(Math.random() * 16.0).toString(16);
            guid += n;
            if (i === 8 || i === 12 || i === 16 || i === 20) {
                guid += '-';
            }
        }
        return guid;
    },

    deepCopy(target) {
        let copyed_objs = [];//此数组解决了循环引用和相同引用的问题，它存放已经递归到的目标对象
        function _deepCopy(target) {
            if ((typeof target !== 'object') || !target) {
                return target;
            }
            for (let i = 0; i < copyed_objs.length; i++) {
                if (copyed_objs[i].target === target) {
                    return copyed_objs[i].copyTarget;
                }
            }
            let obj = {};
            if (Array.isArray(target)) {
                obj = [];//处理target是数组的情况
            }
            copyed_objs.push({target: target, copyTarget: obj})
            Object.keys(target).forEach(key => {
                if (obj[key]) {
                    return;
                }
                obj[key] = _deepCopy(target[key]);
            });
            return obj;
        }
        return _deepCopy(target);
    },

};

export default Data;
